Annotated notes
Original Project Proposal
Program increment (PI) planning
KEY:
Milestone or event
Feature or enablers
Significant dependency
Program Increment (PI) Planning part of the SAFe (Scaled Agile Framework) allows Agile Release Train (ART) collaborators to align on milestones, features, stories and releases. Typically done in person with sticky notes and yarn to identify dependencies, use this to template to collaborate with your teams and stakeholders (mark) in real time to plan the roadmap.
ITERATION 1.1 (Due Nov 29)
ITERATION 1.2 (Due Dec 1)
ITERATION 1.3 (Due Dec 6)
MILESTONES
Axyl
Kevin
EXTERNAL DEPENDENCIES
Project github repo: https://github.com/axyl-casc/Scheduler-Designer/
Project github website: https://axyl-casc.github.io/Scheduler-Designer/
Original Rough Concept
html form where you can build your own process and add it to the proess list
saved in localstorage
PCB
Process Control Block
p1
p2
p3
p4
p5
(shows when p1 clicked)
p1 - priority:
etc:
Results windows has:
gantt chart
box plot for the stats needed
[process name]
[*****]
[*****]
Processes in state ______:
p2
p7
p3
....
FIRST ITERATION:
Make a list of processes, such as {P1, P2} next to each state, that update and move in real time
ALT IDEA:
Make all the processes/queues visible only when you click a state in a pop-up box
Simulation API - Connected to the simulation <div>
- possible undo / redo / step / back-step
initialize(process_list, scheduling_algorithm)
run()
pause()
setSpeed(speedValue)
showProcessNames(bool)
getProcessInfo(process_id)
Dropdown boxes for Processes in main screen that shows additional information
PCB (not literal, the one for this)
- ID
- Process Name
- state
- priority
- IS AN IO PROCESS (?)
- process activity
what the process is doing
based on percent chance (interrupt / running / waiting)
toast for if a process hits an i/o event, so it doesnt seem like its just randomly moving around
events where stuff can happen
1. process changes state
2. ????
Have some kind of visual feedback that updates every context switch / every event-->
Basic Simulation of processing going through the various process states
Results Page:
Populated from simulation data/calculations?
Need to figure this out
About Page
- opens in new tab
Simulation - Creating a step forwards/backwards functionality (saving process states and being able to load the prev/next)
Algorithem Writing -
Being able to write/load your own CPU scheduling algorithms
Simulation Skeleton
Home Page - html/css styling
Home Page -
-Button Functionalities
PCB Builder - css/html screen
CSS/HTML website formatting and styling done for main screen
CSS/HTML website formatting and styling done for PCB builder screen
About page -
about us :)
UI - Button functionality for changing web pages and changing simulation/result view
Have a process add menu - each process is added through an html form element
Simulation Skeleton
Home page must be made
Populate Simulation Process List with
correct info
An I/O burst refers to a period during which a process performs input/output (I/O) operations, such as reading from or writing to a disk or network device. It is part of the behavior of processes in modern operating systems, where processes alternate between two distinct phases:
CPU bursts: The process spends time using the CPU for computations.
I/O bursts: The process waits for I/O operations to complete, such as fetching data from storage or communicating over a network.
These alternating phases are central to the operation of multitasking operating systems, as they allow the OS to overlap CPU usage by one process with I/O operations of another. Processes with frequent I/O bursts are typically considered I/O-bound, while those with long CPU bursts are classified as CPU-bound.
Understanding I/O bursts is critical for designing efficient scheduling algorithms, which aim to balance system responsiveness and throughput by alternating between I/O-bound and CPU-bound processes.
Move the processes around the diagram
Implement a basic FIFO algorithm
display something in the results page
Home Page -
-Populate process list
-local storage for data
-clear storage
Results Page:
Populated from simulation data/calculations?
Need to figure this out
Have some kind of visual feedback that updates every context switch / every event-->
Results Page:
CPU utilization:
-goal of a cpu scheduler is typically to keep the CPU as busy as possible
Throughput:
-Number of processes being executed and completed per unit of time
Turn-around time:
=completion time - arrival time
Waiting Time:
=turnaround time - burst time
Response Time:
Process submission time until first response
Completion Time:
Completed its execution entirely
process no | arrival time | burst time | completion time | turnaround time | waiting time | response time
Total _________ time
average _______ time
_____ = {completion, turnaround, waiting, response}
Process Number (Process ID):
A unique identifier assigned to each process.
Arrival Time:
The time when a process enters the ready queue and is ready to execute.
Typically measured in seconds or milliseconds from the start of the scheduling simulation.
Burst Time (Execution Time):
The total time a process requires on the CPU.
Does not include waiting time in queues.
Completion Time:
The time when a process finishes execution.
Includes both CPU burst time and any waiting or delay the process experienced.
Formula:
Completion Time=Start Time+Burst Time
Turnaround Time:
The total time a process takes from arrival to completion.
Indicates the total delay experienced by a process.
Formula:
Turnaround Time=Completion Time−Arrival Time
Waiting Time:
The total time a process spends waiting in the ready queue before execution.
Calculated as the difference between turnaround time and burst time.
Formula:
Waiting Time=Turnaround Time−Burst Time
Response Time:
The time from a process’s arrival in the ready queue to the first time it gets CPU attention.
This metric is particularly important for interactive systems.
Formula:
Response Time=First Response Time−Arrival Time
Have a working results page, include gantt charts and box plots
Implement additonal scheduling algorithms as time permits